Dart is the programming language used with Flutter for building modern applications. It provides the programming features required to create application logic, user interfaces, data models, API communication, asynchronous operations, and reusable components.
JustAcademy's Flutter curriculum introduces Dart as a core part of Flutter development and covers variables, data types, operators, control statements, functions, object-oriented programming, collections, and asynchronous programming with Future and async/await.
Explore JustAcademy's Flutter Training
Register for Flutter Course Demo
Dart is a modern, general-purpose programming language used to develop applications with Flutter. In a Flutter project, Dart is used to write application logic and define widgets, classes, functions, data structures, event handling, and asynchronous operations.
Dart is especially important for Flutter developers because Flutter applications are written using Dart. JustAcademy's Flutter course therefore introduces Dart before moving into Flutter widgets, UI development, API integration, Firebase, testing, debugging, and complete application development.
Dart provides many features that make it suitable for modern application development. The major features include:
One of Dart's important features is its relatively simple and readable syntax. Developers familiar with languages using C-style syntax can generally understand Dart code quickly.
void main() {
String name = "Amit";
int age = 22;
print("Name: $name");
print("Age: $age");
}The syntax is concise while still providing explicit types when required.
Dart supports Object-Oriented Programming, commonly called OOP. OOP is an important feature for developing structured and reusable applications.
Important OOP concepts in Dart include:
class Student {
String name;
int age;
Student(this.name, this.age);
void display() {
print("Name: $name");
print("Age: $age");
}
}
void main() {
Student student = Student("Rahul", 21);
student.display();
}Flutter itself uses classes extensively. Widgets, screens, models, services, and many other application components can be represented using Dart classes.
Dart supports strong typing. Developers can specify the type of data that a variable is expected to contain.
String name = "Rahul";
int age = 25;
double salary = 45000.50;
bool isActive = true;Using appropriate types makes code easier to understand and helps catch many programming errors during development.
| Type | Purpose | Example |
|---|---|---|
| int | Whole numbers | int age = 25; |
| double | Decimal numbers | double price = 99.50; |
| String | Text | String name = "Amit"; |
| bool | True or false values | bool active = true; |
| List | Ordered collection | List |
| Set | Unique collection | Set |
| Map | Key-value collection | Map |
Dart can automatically determine the type of a variable when var is used and the initial value provides enough information.
var name = "Flutter";
var age = 25;
var price = 999.99;Dart determines that these variables represent a String, int, and double respectively.
Type inference helps developers write concise code while retaining strong type checking.
Null safety is an important Dart feature that helps developers distinguish between values that can contain null and values that should not be null.
String name = "Flutter";The variable above is expected to contain a String value.
String? nickname;The ? indicates that the variable can contain either a String or null.
String? name;
print(name ?? "Guest");The ?? operator provides a fallback value when the value on the left is null.
Mobile applications frequently perform operations that take time, such as API requests, database operations, file operations, and Firebase requests. Dart provides asynchronous programming features for handling these operations.
Important asynchronous features include:
FutureasyncawaitStreamFuture loadData() async {
await Future.delayed(
Duration(seconds: 2),
);
return "Data loaded";
}
void main() async {
String result = await loadData();
print(result);
}JustAcademy's Flutter curriculum specifically includes asynchronous programming using Future and async/await as part of Dart programming fundamentals.
A Future represents a value or result that will become available later.
Future getUserName() async {
return "Rahul";
}
void main() async {
String name = await getUserName();
print(name);
}Futures are commonly used when working with network requests, databases, authentication, and other asynchronous operations.
The async keyword identifies a function that performs asynchronous work, while await allows the program to wait for an asynchronous result.
Future fetchData() async {
print("Fetching data...");
await Future.delayed(
Duration(seconds: 2),
);
print("Data received");
}
void main() async {
await fetchData();
}These features are particularly important when developing Flutter applications that communicate with APIs or cloud services.
A Stream allows an application to receive a sequence of asynchronous values over time.
Stream numbers() async* {
for (int i = 1; i <= 5; i++) {
yield i;
}
}
void main() async {
await for (int number in numbers()) {
print(number);
}
}Streams can be useful for continuously changing data, real-time information, event-based operations, and other situations where values arrive over time.
Dart provides built-in collection types that are heavily used in Flutter applications.
A List stores values in an ordered collection.
List products = [
"Laptop",
"Mobile",
"Tablet"
];
print(products[0]);A Set stores unique values.
Set skills = {
"Dart",
"Flutter",
"Firebase"
};A Map stores data as key-value pairs.
Map user = {
"name": "Amit",
"age": 24,
"active": true
};JustAcademy's Dart curriculum specifically covers List, Set, and Map collections.
Functions in Dart can be stored in variables, passed as arguments, and returned from other functions.
void sayHello() {
print("Hello");
}
void executeFunction(void Function() function) {
function();
}
void main() {
executeFunction(sayHello);
}This feature is particularly useful in Flutter because callbacks are frequently used for buttons, gestures, form events, navigation, and other user interactions.
Dart allows developers to create functions without explicitly giving them a name.
List names = [
"Amit",
"Rahul",
"Priya"
];
names.forEach((name) {
print(name);
});Anonymous functions are commonly used with collection methods and Flutter callbacks.
Dart provides arrow syntax for short functions containing a single expression.
int add(int a, int b) => a + b;
print(add(10, 20));Arrow functions can make short operations more concise and readable.
Dart supports named parameters, which can make function calls easier to understand.
void createUser({
required String name,
required int age,
}) {
print("Name: $name");
print("Age: $age");
}
void main() {
createUser(
name: "Rahul",
age: 25,
);
}Named parameters are widely used in Flutter widget constructors and application code.
Dart supports optional parameters, allowing functions to be called with or without certain arguments.
void greet(String name, [String? message]) {
print("Hello $name");
if (message != null) {
print(message);
}
}
void main() {
greet("Amit");
greet("Rahul", "Welcome to Flutter");
}Dart provides string interpolation for inserting variables and expressions directly into strings.
String name = "Amit";
int age = 25;
print("My name is $name");
print("I am $age years old");Expressions can also be placed inside ${}.
int a = 10;
int b = 20;
print("Total: ${a + b}");Dart provides exception-handling mechanisms for dealing with errors and unexpected situations.
Important keywords include:
trycatchfinallythrowvoid main() {
try {
int result = 10 ~/ 0;
print(result);
} catch (error) {
print("Error: $error");
} finally {
print("Operation completed");
}
}Exception handling is useful when working with APIs, databases, files, authentication, and other operations that can fail.
Generics allow developers to create reusable code that works with specific data types while maintaining type safety.
List names = [
"Amit",
"Rahul",
"Priya"
];
List numbers = [
10,
20,
30
];Here, the generic type specifies the type of values that the List should contain.
Dart supports mixins, which provide a way to reuse functionality across multiple classes without using traditional class inheritance for every behavior.
mixin Logger {
void log(String message) {
print("LOG: $message");
}
}
class UserService with Logger {
void loadUser() {
log("Loading user");
}
}
void main() {
UserService service = UserService();
service.loadUser();
}Mixins can help organize reusable functionality in larger Dart and Flutter applications.
Extension methods allow developers to add functionality to existing types without modifying the original type.
extension StringExtension on String {
String capitalizeFirst() {
if (isEmpty) return this;
return this[0].toUpperCase() + substring(1);
}
}
void main() {
String name = "flutter";
print(name.capitalizeFirst());
}Extension methods can be useful for creating reusable utility functionality.
Dart provides final and const for values that should not be reassigned.
final String name = "Flutter";A final variable can be assigned once.
const int maxUsers = 100;Const values are compile-time constants.
Dart supports variable scopes. A variable declared inside a function or block is generally accessible within that scope.
void main() {
String message = "Hello";
if (true) {
print(message);
}
}Understanding scope is important for managing variables and avoiding naming conflicts in larger Flutter applications.
Dart supports several functional programming concepts, including passing functions as values, anonymous functions, callbacks, and collection operations.
List numbers = [1, 2, 3, 4, 5];
List doubled = numbers
.map((number) => number * 2)
.toList();
print(doubled);These capabilities can help developers write concise and reusable application logic.
Flutter applications frequently communicate with REST APIs that return JSON. Dart's Map and List structures are useful for representing JSON-like data.
Map product = {
"id": 101,
"name": "Laptop",
"price": 55000
};
print(product["name"]);
print(product["price"]);In larger applications, JSON responses are commonly converted into Dart model classes to keep application code organized.
One of Dart's most important roles is its integration with Flutter. Flutter widgets are written using Dart.
import 'package:flutter/material.dart';
class WelcomeScreen extends StatelessWidget {
const WelcomeScreen({super.key});
@override
Widget build(BuildContext context) {
return const Scaffold(
body: Center(
child: Text(
"Welcome to Flutter",
),
),
);
}
}The example uses Dart classes, constructors, methods, and constants together with Flutter's widget system.
Dart makes it possible to organize application logic into reusable functions, classes, services, models, and utilities.
class Calculator {
int add(int a, int b) {
return a + b;
}
int multiply(int a, int b) {
return a * b;
}
}
void main() {
Calculator calculator = Calculator();
print(calculator.add(10, 20));
print(calculator.multiply(5, 4));
}Reusable code helps reduce duplication and makes larger Flutter applications easier to maintain.
Dart works together with Flutter's cross-platform development model. JustAcademy's Flutter course describes development of Android and iOS applications using Flutter and Dart from a shared codebase.
This allows developers to write Dart-based application code that can be used as part of applications targeting multiple platforms supported by Flutter.
Flutter Application
|
v
Dart
|
----------------
| | |
Android iOS Web/Desktop
| Dart Feature | Use in Flutter |
|---|---|
| Classes | Creating widgets, models, services, and application components |
| Functions | Creating reusable logic and callbacks |
| List | Managing collections of items |
| Map | Representing key-value and JSON-like data |
| Null Safety | Handling optional or missing values |
| Future | Handling asynchronous operations |
| async/await | Working with APIs, databases, and cloud services |
| Stream | Handling sequences of asynchronous events or values |
| Generics | Creating type-safe reusable code |
| Exception Handling | Managing errors and unexpected situations |
| Named Parameters | Creating readable function and widget calls |
class Product {
final String name;
final double price;
Product({
required this.name,
required this.price,
});
void display() {
print("Product: $name");
print("Price: ₹$price");
}
}
Future> loadProducts() async {
await Future.delayed(
const Duration(seconds: 1),
);
return [
Product(
name: "Laptop",
price: 55000,
),
Product(
name: "Mobile",
price: 25000,
),
];
}
void main() async {
List products = await loadProducts();
for (Product product in products) {
product.display();
}
}This example demonstrates several Dart features together:
JustAcademy's current Flutter curriculum specifically lists the following Dart fundamentals:
These concepts form the programming foundation before progressing into Flutter's widget system and application development.
| Feature | Short Explanation |
|---|---|
| Simple Syntax | Readable and structured programming syntax. |
| OOP | Supports classes, objects, inheritance, abstraction, and polymorphism. |
| Strong Typing | Supports explicit and reliable data types. |
| Type Inference | Can infer variable types from assigned values. |
| Null Safety | Helps manage nullable and non-nullable values. |
| Future | Represents a result that becomes available asynchronously. |
| async/await | Simplifies asynchronous programming. |
| Streams | Handle sequences of asynchronous values. |
| Collections | Provides List, Set, and Map. |
| Functions | Supports reusable functions and callbacks. |
| Generics | Supports reusable type-safe code. |
| Exception Handling | Helps handle application errors. |
| Named Parameters | Makes function calls clearer and more expressive. |
JustAcademy's Flutter training includes Dart programming as a core part of the curriculum. The course progresses from Dart fundamentals to Flutter widgets, UI development, navigation, API integration, Firebase, state management, testing, debugging, deployment, and practical application development.
Visit JustAcademy Flutter Training
Register for Flutter Course Demo
Dart provides the programming foundation for Flutter development. Its features such as object-oriented programming, strong typing, null safety, collections, functions, asynchronous programming, Future, async/await, Stream, generics, and reusable code structures make it suitable for developing modern applications with Flutter.
A strong understanding of Dart features makes it easier to understand Flutter widgets, application architecture, API integration, Firebase, state management, and real-world Flutter projects.
